/**
 * @file 地理坐标格式化工具函数
 * @description 提供地理坐标相关格式化工具函数
 * @date 2024-06-15
 */

import { logger } from '@/utils/system/logger';

/**
 * 坐标点接口
 */
interface GeoPoint {
  lng: number;
  lat: number;
}

/**
 * 格式化坐标点
 * @param point 坐标点对象
 * @param digits 小数位数
 * @returns 格式化后的坐标字符串
 */
export function formatGeoCoord(point: GeoPoint | null | undefined, digits: number = 6): string {
  if (!point || point.lng === undefined || point.lat === undefined) {
    return '无效坐标';
  }
  
  const lng = typeof point.lng === 'number' ? point.lng.toFixed(digits) : point.lng;
  const lat = typeof point.lat === 'number' ? point.lat.toFixed(digits) : point.lat;
  
  return `${lng}, ${lat}`;
}

/**
 * 格式化经度
 * @param lng 经度
 * @param digits 小数位数
 * @returns 格式化后的经度字符串
 */
export function formatLongitude(lng: number | null | undefined, digits: number = 6): string {
  if (lng === null || lng === undefined || isNaN(lng)) {
    return '无效经度';
  }
  
  return lng.toFixed(digits);
}

/**
 * 格式化纬度
 * @param lat 纬度
 * @param digits 小数位数
 * @returns 格式化后的纬度字符串
 */
export function formatLatitude(lat: number | null | undefined, digits: number = 6): string {
  if (lat === null || lat === undefined || isNaN(lat)) {
    return '无效纬度';
  }
  
  return lat.toFixed(digits);
}

/**
 * @file 地理工具函数
 * @description 提供地理位置计算等功能，使用百度地图官方API
 * @date 2024-07-01
 */

import { formatDistance, formatSpeed } from './distance';

// 导出format.ts中的格式化函数，保持向后兼容
export { formatDistance, formatSpeed };

/**
 * 使用百度地图API计算两个经纬度坐标之间的距离
 * @param lat1 第一个点的纬度
 * @param lon1 第一个点的经度
 * @param lat2 第二个点的纬度
 * @param lon2 第二个点的经度
 * @returns 距离，单位为米
 */
export function getDistance(lat1: number, lon1: number, lat2: number, lon2: number): number {
  if (typeof window === 'undefined' || !window.BMapGL) {
    logger.warn('百度地图API不可用，无法计算距离');
    return 0;
  }

  try {
    const point1 = new window.BMapGL.Point(lon1, lat1);
    const point2 = new window.BMapGL.Point(lon2, lat2);
    return window.BMapGL.Projection.getDistance(point1, point2);
  } catch (error) {
    logger.error('使用百度地图API计算距离时发生错误:', error);
    return 0;
  }
}

/**
 * 使用百度地图API计算一系列轨迹点的总距离
 * @param points 轨迹点数组，每个点必须有latitude和longitude属性
 * @returns 总距离，单位为米
 */
export function calculateTotalDistance(points: Array<{ latitude: number; longitude: number }>): number {
  if (!points || points.length < 2 || typeof window === 'undefined' || !window.BMapGL) {
    return 0;
  }
  
  try {
    // 转换为百度地图点对象
    const baiduPoints = points.map(p => new window.BMapGL.Point(p.longitude, p.latitude));
    
    // 创建折线实例
    const polyline = new window.BMapGL.Polyline(baiduPoints, {});
    
    // 使用官方API计算总长度
    return (polyline as any).getLength();
  } catch (error) {
    logger.error('使用百度地图API计算轨迹总距离时发生错误:', error);
    return 0;
  }
}

/**
 * 使用百度地图API计算一系列轨迹点的平均速度
 * @param points 轨迹点数组，每个点必须有latitude、longitude和timestamp属性
 * @returns 平均速度，单位为米/秒，如果无法计算则返回0
 */
export function calculateAverageSpeed(
  points: Array<{ latitude: number; longitude: number; timestamp: number | string }>
): number {
  if (!points || points.length < 2) {
    return 0;
  }
  
  const totalDistance = calculateTotalDistance(points);
  
  // 计算时间差（秒）
  const startTime = typeof points[0].timestamp === 'string' 
    ? new Date(points[0].timestamp).getTime() 
    : +points[0].timestamp;
    
  const endTime = typeof points[points.length - 1].timestamp === 'string'
    ? new Date(points[points.length - 1].timestamp).getTime()
    : +points[points.length - 1].timestamp;
    
  const timeDiffSeconds = (endTime - startTime) / 1000;
  
  if (timeDiffSeconds <= 0) {
    return 0;
  }
  
  return totalDistance / timeDiffSeconds;
}

/**
 * 判断点是否在多边形内（使用百度地图API）
 * @param point 点的坐标 [经度, 纬度]
 * @param polygon 多边形的顶点坐标数组，每个元素为 [经度, 纬度]
 * @returns 如果点在多边形内，返回true；否则返回false
 */
export function isPointInPolygon(point: [number, number], polygon: Array<[number, number]>): boolean {
  if (typeof window === 'undefined' || !window.BMapGL) {
    logger.warn('百度地图API不可用，无法检查点是否在多边形内');
    return false;
  }

  try {
    // 创建点对象
    const baiduPoint = new window.BMapGL.Point(point[0], point[1]);
    
    // 创建多边形对象
    const polygonPoints = polygon.map(p => new window.BMapGL.Point(p[0], p[1]));
    // 使用类型断言处理BMapGL.Polygon
    const baiduPolygon = new (window.BMapGL as any).Polygon(polygonPoints);
    
    // 使用类型断言处理BMapGL.Geometry
    return ((window.BMapGL as any).Geometry).isPointInPolygon(baiduPoint, baiduPolygon);
  } catch (error) {
    logger.error('使用百度地图API检查点是否在多边形内时发生错误:', error);
    return false;
  }
}

/**
 * 计算百度地图轨迹点的总距离
 * @param points 轨迹点数组
 * @returns 轨迹总距离(公里)
 */
export function calculateBMapTrackDistance(points: any[]): number {
  if (!points || points.length < 2) {
    return 0;
  }
  
  // 检查BMapGL是否已加载
  if (typeof window !== 'undefined' && window.BMapGL && window.BMapGL.Polyline) {
    try {
      // 转换轨迹点为百度地图点对象
      const baiduPoints = points.map(p => {
        const lng = p.lng || (p.position ? p.position.lng : 0);
        const lat = p.lat || (p.position ? p.position.lat : 0);
        return new window.BMapGL.Point(lng, lat);
      });
      
      // 创建折线实例，不需要添加到地图上
      const polyline = new window.BMapGL.Polyline(baiduPoints, {});
      
      // 使用百度地图官方API计算距离
      return (polyline as any).getLength() / 1000; // 转换为千米
    } catch (error) {
      logger.error('使用百度地图API计算轨迹距离失败:', error);
      return 0;
    }
  }
  
  // 无法使用百度地图API时返回0
  logger.warn('百度地图API不可用，无法计算轨迹距离');
  return 0;
} 